function cipher() {
    var date = new Date();
    var timestamp = date.getTime().toString();
    var salt = $.WebSite.random(24);
    var year = date.getFullYear().toString();
    var month = (date.getMonth() + 1 < 10 ? "0" + (date.getMonth() + 1) : date
        .getMonth()+1).toString();
    var day = (date.getDate() < 10 ? "0" + date.getDate() : date.getDate())
        .toString();
    var iv = year + month + day;
    var enc = DES3.encrypt(timestamp, salt, iv).toString();
    var str = salt + iv + enc;
    var ciphertext = strTobinary(str);
    return ciphertext;
}
function strTobinary(str) {
    var result = [];
    var list = str.split("");
    for (var i = 0; i < list.length; i++) {
        if (i != 0) {
            result.push(" ");
        }
        var item = list[i];
        var binaryStr = item.charCodeAt().toString(2);
        result.push(binaryStr);
    };
    return result.join("");
}
var DES3 = {
    iv:function(){
        return $.WebSite.formatDate(new Date(),"yyyyMMdd")
    },
    encrypt:function(b,c,a){
        if(c){
            return(CryptoJS.TripleDES.encrypt(b,CryptoJS.enc.Utf8.parse(c),{
                iv:CryptoJS.enc.Utf8.parse(a||DES3.iv()),
                mode:CryptoJS.mode.CBC,
                padding:CryptoJS.pad.Pkcs7
            })).toString()
        }
        return""
    },
    decrypt:function(b,c,a){
        if(c){return CryptoJS.enc.Utf8.stringify(CryptoJS.TripleDES.decrypt(b,CryptoJS.enc.Utf8.parse(c),{
            iv:CryptoJS.enc.Utf8.parse(a||DES3.iv()),
            mode:CryptoJS.mode.CBC,padding:CryptoJS.pad.Pkcs7
        })).toString()
        }
        return""
    }
};
var CryptoJS = CryptoJS || function(y, h) { var j = {},
    g = j.lib = {},
    f = function() {},
    z = g.Base = { extend: function(b) { f.prototype = this; var d = new f;
            b && d.mixIn(b);
            d.hasOwnProperty("init") || (d.init = function() { d.$super.init.apply(this, arguments) });
            d.init.prototype = d;
            d.$super = this; return d }, create: function() { var b = this.extend();
            b.init.apply(b, arguments); return b }, init: function() {}, mixIn: function(b) { for (var d in b) { b.hasOwnProperty(d) && (this[d] = b[d]) } b.hasOwnProperty("toString") && (this.toString = b.toString) }, clone: function() { return this.init.prototype.extend(this) } },
    c = g.WordArray = z.extend({ init: function(b, d) { b = this.words = b || [];
            this.sigBytes = d != h ? d : 4 * b.length }, toString: function(b) { return (b || t).stringify(this) }, concat: function(d) { var n = this.words,
            b = d.words,
            l = this.sigBytes;
            d = d.sigBytes;
            this.clamp(); if (l % 4) { for (var e = 0; e < d; e++) { n[l + e >>> 2] |= (b[e >>> 2] >>> 24 - 8 * (e % 4) & 255) << 24 - 8 * ((l + e) % 4) } } else { if (65535 < b.length) { for (e = 0; e < d; e += 4) { n[l + e >>> 2] = b[e >>> 2] } } else { n.push.apply(n, b) } } this.sigBytes += d; return this }, clamp: function() { var b = this.words,
            d = this.sigBytes;
            b[d >>> 2] &= 4294967295 << 32 - 8 * (d % 4);
            b.length = y.ceil(d / 4) }, clone: function() { var b = z.clone.call(this);
            b.words = this.words.slice(0); return b }, random: function(d) { for (var e = [], b = 0; b < d; b += 4) { e.push(4294967296 * y.random() | 0) } return new c.init(e, d) } }),
    o = j.enc = {},
    t = o.Hex = { stringify: function(d) { var n = d.words;
            d = d.sigBytes; for (var b = [], l = 0; l < d; l++) { var e = n[l >>> 2] >>> 24 - 8 * (l % 4) & 255;
                b.push((e >>> 4).toString(16));
                b.push((e & 15).toString(16)) } return b.join("") }, parse: function(d) { for (var l = d.length, b = [], e = 0; e < l; e += 2) { b[e >>> 3] |= parseInt(d.substr(e, 2), 16) << 24 - 4 * (e % 8) } return new c.init(b, l / 2) } },
    k = o.Latin1 = { stringify: function(d) { var l = d.words;
            d = d.sigBytes; for (var b = [], e = 0; e < d; e++) { b.push(String.fromCharCode(l[e >>> 2] >>> 24 - 8 * (e % 4) & 255)) } return b.join("") }, parse: function(d) { for (var l = d.length, b = [], e = 0; e < l; e++) { b[e >>> 2] |= (d.charCodeAt(e) & 255) << 24 - 8 * (e % 4) } return new c.init(b, l) } },
    m = o.Utf8 = { stringify: function(b) { try { return decodeURIComponent(escape(k.stringify(b))) } catch (d) { throw Error("Malformed UTF-8 data") } }, parse: function(b) { return k.parse(unescape(encodeURIComponent(b))) } },
    a = g.BufferedBlockAlgorithm = z.extend({ reset: function() { this._data = new c.init;
            this._nDataBytes = 0 }, _append: function(b) { "string" == typeof b && (b = m.parse(b));
            this._data.concat(b);
            this._nDataBytes += b.sigBytes }, _process: function(n) { var s = this._data,
            l = s.words,
            q = s.sigBytes,
            p = this.blockSize,
            d = q / (4 * p),
            d = n ? y.ceil(d) : y.max((d | 0) - this._minBufferSize, 0);
            n = d * p;
            q = y.min(4 * n, q); if (n) { for (var r = 0; r < n; r += p) { this._doProcessBlock(l, r) } r = l.splice(0, n);
                s.sigBytes -= q } return new c.init(r, q) }, clone: function() { var b = z.clone.call(this);
            b._data = this._data.clone(); return b }, _minBufferSize: 0 });
    g.Hasher = a.extend({ cfg: z.extend(), init: function(b) { this.cfg = this.cfg.extend(b);
            this.reset() }, reset: function() { a.reset.call(this);
            this._doReset() }, update: function(b) { this._append(b);
            this._process(); return this }, finalize: function(b) { b && this._append(b); return this._doFinalize() }, blockSize: 16, _createHelper: function(b) { return function(e, d) { return (new b.init(d)).finalize(e) } }, _createHmacHelper: function(b) { return function(e, d) { return (new i.HMAC.init(b, d)).finalize(e) } } }); var i = j.algo = {}; return j }(Math);
(function() { var b = CryptoJS,
    a = b.lib.WordArray;
    b.enc.Base64 = { stringify: function(i) { var j = i.words,
            e = i.sigBytes,
            g = this._map;
            i.clamp();
            i = []; for (var h = 0; h < e; h += 3) { for (var c = (j[h >>> 2] >>> 24 - 8 * (h % 4) & 255) << 16 | (j[h + 1 >>> 2] >>> 24 - 8 * ((h + 1) % 4) & 255) << 8 | j[h + 2 >>> 2] >>> 24 - 8 * ((h + 2) % 4) & 255, f = 0; 4 > f && h + 0.75 * f < e; f++) { i.push(g.charAt(c >>> 6 * (3 - f) & 63)) } } if (j = g.charAt(64)) { for (; i.length % 4;) { i.push(j) } } return i.join("") }, parse: function(j) { var k = j.length,
            i = this._map,
            g = i.charAt(64);
            g && (g = j.indexOf(g), -1 != g && (k = g)); for (var g = [], h = 0, e = 0; e < k; e++) { if (e % 4) { var f = i.indexOf(j.charAt(e - 1)) << 2 * (e % 4),
                c = i.indexOf(j.charAt(e)) >>> 6 - 2 * (e % 4);
                g[h >>> 2] |= (f | c) << 24 - 8 * (h % 4);
                h++ } } return a.create(g, h) }, _map: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=" } })();
(function(m) {
    function f(l, r, n, s, d, q, p) { l = l + (r & n | ~r & s) + d + p; return (l << q | l >>> 32 - q) + r }

    function g(l, r, n, s, d, q, p) { l = l + (r & s | n & ~s) + d + p; return (l << q | l >>> 32 - q) + r }

    function e(l, r, n, s, d, q, p) { l = l + (r ^ n ^ s) + d + p; return (l << q | l >>> 32 - q) + r }

    function c(l, r, n, s, d, q, p) { l = l + (n ^ (r | ~s)) + d + p; return (l << q | l >>> 32 - q) + r }
    for (var o = CryptoJS, a = o.lib, j = a.WordArray, k = a.Hasher, a = o.algo, h = [], i = 0; 64 > i; i++) { h[i] = 4294967296 * m.abs(m.sin(i + 1)) | 0 } a = a.MD5 = k.extend({
        _doReset: function() { this._hash = new j.init([1732584193, 4023233417, 2562383102, 271733878]) },
        _doProcessBlock: function(J, T) {
            for (var V = 0; 16 > V; V++) { var U = T + V,
                N = J[U];
                J[U] = (N << 8 | N >>> 24) & 16711935 | (N << 24 | N >>> 8) & 4278255360 }
            var V = this._hash.words,
                U = J[T + 0],
                N = J[T + 1],
                S = J[T + 2],
                F = J[T + 3],
                d = J[T + 4],
                L = J[T + 5],
                H = J[T + 6],
                n = J[T + 7],
                p = J[T + 8],
                E = J[T + 9],
                l = J[T + 10],
                b = J[T + 11],
                M = J[T + 12],
                K = J[T + 13],
                I = J[T + 14],
                G = J[T + 15],
                R = V[0],
                Q = V[1],
                P = V[2],
                O = V[3],
                R = f(R, Q, P, O, U, 7, h[0]),
                O = f(O, R, Q, P, N, 12, h[1]),
                P = f(P, O, R, Q, S, 17, h[2]),
                Q = f(Q, P, O, R, F, 22, h[3]),
                R = f(R, Q, P, O, d, 7, h[4]),
                O = f(O, R, Q, P, L, 12, h[5]),
                P = f(P, O, R, Q, H, 17, h[6]),
                Q = f(Q, P, O, R, n, 22, h[7]),
                R = f(R, Q, P, O, p, 7, h[8]),
                O = f(O, R, Q, P, E, 12, h[9]),
                P = f(P, O, R, Q, l, 17, h[10]),
                Q = f(Q, P, O, R, b, 22, h[11]),
                R = f(R, Q, P, O, M, 7, h[12]),
                O = f(O, R, Q, P, K, 12, h[13]),
                P = f(P, O, R, Q, I, 17, h[14]),
                Q = f(Q, P, O, R, G, 22, h[15]),
                R = g(R, Q, P, O, N, 5, h[16]),
                O = g(O, R, Q, P, H, 9, h[17]),
                P = g(P, O, R, Q, b, 14, h[18]),
                Q = g(Q, P, O, R, U, 20, h[19]),
                R = g(R, Q, P, O, L, 5, h[20]),
                O = g(O, R, Q, P, l, 9, h[21]),
                P = g(P, O, R, Q, G, 14, h[22]),
                Q = g(Q, P, O, R, d, 20, h[23]),
                R = g(R, Q, P, O, E, 5, h[24]),
                O = g(O, R, Q, P, I, 9, h[25]),
                P = g(P, O, R, Q, F, 14, h[26]),
                Q = g(Q, P, O, R, p, 20, h[27]),
                R = g(R, Q, P, O, K, 5, h[28]),
                O = g(O, R, Q, P, S, 9, h[29]),
                P = g(P, O, R, Q, n, 14, h[30]),
                Q = g(Q, P, O, R, M, 20, h[31]),
                R = e(R, Q, P, O, L, 4, h[32]),
                O = e(O, R, Q, P, p, 11, h[33]),
                P = e(P, O, R, Q, b, 16, h[34]),
                Q = e(Q, P, O, R, I, 23, h[35]),
                R = e(R, Q, P, O, N, 4, h[36]),
                O = e(O, R, Q, P, d, 11, h[37]),
                P = e(P, O, R, Q, n, 16, h[38]),
                Q = e(Q, P, O, R, l, 23, h[39]),
                R = e(R, Q, P, O, K, 4, h[40]),
                O = e(O, R, Q, P, U, 11, h[41]),
                P = e(P, O, R, Q, F, 16, h[42]),
                Q = e(Q, P, O, R, H, 23, h[43]),
                R = e(R, Q, P, O, E, 4, h[44]),
                O = e(O, R, Q, P, M, 11, h[45]),
                P = e(P, O, R, Q, G, 16, h[46]),
                Q = e(Q, P, O, R, S, 23, h[47]),
                R = c(R, Q, P, O, U, 6, h[48]),
                O = c(O, R, Q, P, n, 10, h[49]),
                P = c(P, O, R, Q, I, 15, h[50]),
                Q = c(Q, P, O, R, L, 21, h[51]),
                R = c(R, Q, P, O, M, 6, h[52]),
                O = c(O, R, Q, P, F, 10, h[53]),
                P = c(P, O, R, Q, l, 15, h[54]),
                Q = c(Q, P, O, R, N, 21, h[55]),
                R = c(R, Q, P, O, p, 6, h[56]),
                O = c(O, R, Q, P, G, 10, h[57]),
                P = c(P, O, R, Q, H, 15, h[58]),
                Q = c(Q, P, O, R, K, 21, h[59]),
                R = c(R, Q, P, O, d, 6, h[60]),
                O = c(O, R, Q, P, b, 10, h[61]),
                P = c(P, O, R, Q, S, 15, h[62]),
                Q = c(Q, P, O, R, E, 21, h[63]);
            V[0] = V[0] + R | 0;
            V[1] = V[1] + Q | 0;
            V[2] = V[2] + P | 0;
            V[3] = V[3] + O | 0
        },
        _doFinalize: function() { var l = this._data,
            p = l.words,
            n = 8 * this._nDataBytes,
            q = 8 * l.sigBytes;
            p[q >>> 5] |= 128 << 24 - q % 32; var d = m.floor(n / 4294967296);
            p[(q + 64 >>> 9 << 4) + 15] = (d << 8 | d >>> 24) & 16711935 | (d << 24 | d >>> 8) & 4278255360;
            p[(q + 64 >>> 9 << 4) + 14] = (n << 8 | n >>> 24) & 16711935 | (n << 24 | n >>> 8) & 4278255360;
            l.sigBytes = 4 * (p.length + 1);
            this._process();
            l = this._hash;
            p = l.words; for (n = 0; 4 > n; n++) { q = p[n], p[n] = (q << 8 | q >>> 24) & 16711935 | (q << 24 | q >>> 8) & 4278255360 } return l },
        clone: function() { var d = k.clone.call(this);
            d._hash = this._hash.clone(); return d }
    });
    o.MD5 = k._createHelper(a);
    o.HmacMD5 = k._createHmacHelper(a)
})(Math);
(function() { var b = CryptoJS,
    a = b.lib,
    e = a.Base,
    f = a.WordArray,
    a = b.algo,
    c = a.EvpKDF = e.extend({ cfg: e.extend({ keySize: 4, hasher: a.MD5, iterations: 1 }), init: function(g) { this.cfg = this.cfg.extend(g) }, compute: function(k, i) { for (var h = this.cfg, o = h.hasher.create(), m = f.create(), q = m.words, g = h.keySize, h = h.iterations; q.length < g;) { j && o.update(j); var j = o.update(k).finalize(i);
            o.reset(); for (var n = 1; n < h; n++) { j = o.finalize(j), o.reset() } m.concat(j) } m.sigBytes = 4 * g; return m } });
    b.EvpKDF = function(h, g, i) { return c.create(i).compute(h, g) } })();
CryptoJS.lib.Cipher || function(C) {
    var j = CryptoJS,
        m = j.lib,
        i = m.Base,
        h = m.WordArray,
        D = m.BufferedBlockAlgorithm,
        g = j.enc.Base64,
        A = j.algo.EvpKDF,
        B = m.Cipher = D.extend({ cfg: i.extend(), createEncryptor: function(b, c) { return this.create(this._ENC_XFORM_MODE, b, c) }, createDecryptor: function(b, c) { return this.create(this._DEC_XFORM_MODE, b, c) }, init: function(d, e, c) { this.cfg = this.cfg.extend(c);
                this._xformMode = d;
                this._key = e;
                this.reset() }, reset: function() { D.reset.call(this);
                this._doReset() }, process: function(b) { this._append(b); return this._process() }, finalize: function(b) { b && this._append(b); return this._doFinalize() }, keySize: 4, ivSize: 4, _ENC_XFORM_MODE: 1, _DEC_XFORM_MODE: 2, _createHelper: function(a) { return { encrypt: function(d, c, l) { return ("string" == typeof c ? o : y).encrypt(a, d, c, l) }, decrypt: function(d, c, l) { return ("string" == typeof c ? o : y).decrypt(a, d, c, l) } } } });
    m.StreamCipher = B.extend({ _doFinalize: function() { return this._process(!0) }, blockSize: 1 });
    var t = j.mode = {},
        z = function(l, n, d) { var q = this._iv;
            q ? this._iv = C : q = this._prevBlock; for (var p = 0; p < d; p++) { l[n + p] ^= q[p] } },
        f = (m.BlockCipherMode = i.extend({ createEncryptor: function(b, c) { return this.Encryptor.create(b, c) }, createDecryptor: function(b, c) { return this.Decryptor.create(b, c) }, init: function(b, c) { this._cipher = b;
                this._iv = c } })).extend();
    f.Encryptor = f.extend({ processBlock: function(e, l) { var d = this._cipher,
            n = d.blockSize;
            z.call(this, e, l, n);
            d.encryptBlock(e, l);
            this._prevBlock = e.slice(l, l + n) } });
    f.Decryptor = f.extend({ processBlock: function(n, l) { var r = this._cipher,
            p = r.blockSize,
            q = n.slice(l, l + p);
            r.decryptBlock(n, l);
            z.call(this, n, l, p);
            this._prevBlock = q } });
    t = t.CBC = f;
    f = (j.pad = {}).Pkcs7 = { pad: function(q, n) { for (var u = 4 * n, u = u - q.sigBytes % u, r = u << 24 | u << 16 | u << 8 | u, s = [], p = 0; p < u; p += 4) { s.push(r) } u = h.create(s, u);
            q.concat(u) }, unpad: function(b) { b.sigBytes -= b.words[b.sigBytes - 1 >>> 2] & 255 } };
    m.BlockCipher = B.extend({ cfg: B.cfg.extend({ mode: t, padding: f }), reset: function() { B.reset.call(this); var e = this.cfg,
            l = e.iv,
            e = e.mode; if (this._xformMode == this._ENC_XFORM_MODE) { var d = e.createEncryptor } else { d = e.createDecryptor, this._minBufferSize = 1 } this._mode = d.call(e, this, l && l.words) }, _doProcessBlock: function(b, d) { this._mode.processBlock(b, d) }, _doFinalize: function() { var b = this.cfg.padding; if (this._xformMode == this._ENC_XFORM_MODE) { b.pad(this._data, this.blockSize); var d = this._process(!0) } else { d = this._process(!0), b.unpad(d) } return d }, blockSize: 4 });
    var k = m.CipherParams = i.extend({ init: function(b) { this.mixIn(b) }, toString: function(b) { return (b || this.formatter).stringify(this) } }),
        t = (j.format = {}).OpenSSL = { stringify: function(b) { var d = b.ciphertext;
                b = b.salt; return (b ? h.create([1398893684, 1701076831]).concat(b).concat(d) : d).toString(g) }, parse: function(e) { e = g.parse(e); var l = e.words; if (1398893684 == l[0] && 1701076831 == l[1]) { var d = h.create(l.slice(2, 4));
                l.splice(0, 4);
                e.sigBytes -= 16 } return k.create({ ciphertext: e, salt: d }) } },
        y = m.SerializableCipher = i.extend({ cfg: i.extend({ format: t }), encrypt: function(p, r, e, q) { q = this.cfg.extend(q); var n = p.createEncryptor(e, q);
                r = n.finalize(r);
                n = n.cfg; return k.create({ ciphertext: r, key: e, iv: n.iv, algorithm: p, mode: n.mode, padding: n.padding, blockSize: p.blockSize, formatter: q.format }) }, decrypt: function(l, p, d, n) { n = this.cfg.extend(n);
                p = this._parse(p, n.format); return l.createDecryptor(d, n).finalize(p.ciphertext) }, _parse: function(b, d) { return "string" == typeof b ? d.parse(b, this) : b } }),
        j = (j.kdf = {}).OpenSSL = { execute: function(l, p, e, n) { n || (n = h.random(8));
                l = A.create({ keySize: p + e }).compute(l, n);
                e = h.create(l.words.slice(p), 4 * e);
                l.sigBytes = 4 * p; return k.create({ key: l, iv: e, salt: n }) } },
        o = m.PasswordBasedCipher = y.extend({ cfg: y.cfg.extend({ kdf: j }), encrypt: function(p, a, l, n) { n = this.cfg.extend(n);
                l = n.kdf.execute(l, p.keySize, p.ivSize);
                n.iv = l.iv;
                p = y.encrypt.call(this, p, a, l.key, n);
                p.mixIn(l); return p }, decrypt: function(p, a, l, n) { n = this.cfg.extend(n);
                a = this._parse(a, n.format);
                l = n.kdf.execute(l, p.keySize, p.ivSize, a.salt);
                n.iv = l.iv; return y.decrypt.call(this, p, a, l.key, n) } })
}();
